/*! Scroller 1.2.2
 * ©2011-2014 SpryMedia Ltd - datatables.net/license
 */

/**
 * @summary     Scroller
 * @description Virtual rendering for DataTables
 * @version     1.2.2
 * @file        dataTables.scroller.js
 * @author      SpryMedia Ltd (www.sprymedia.co.uk)
 * @contact     www.sprymedia.co.uk/contact
 * @copyright   Copyright 2011-2014 SpryMedia Ltd.
 *
 * This source file is free software, available under the following license:
 *   MIT license - http://datatables.net/license/mit
 *
 * This source file is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
 *
 * For details please refer to: http://www.datatables.net
 */

(function (window, document, undefined) {


    var factory = function ($, DataTable) {
        "use strict";

        /**
         * Scroller is a virtual rendering plug-in for DataTables which allows large
         * datasets to be drawn on screen every quickly. What the virtual rendering means
         * is that only the visible portion of the table (and a bit to either side to make
         * the scrolling smooth) is drawn, while the scrolling container gives the
         * visual impression that the whole table is visible. This is done by making use
         * of the pagination abilities of DataTables and moving the table around in the
         * scrolling container DataTables adds to the page. The scrolling container is
         * forced to the height it would be for the full table display using an extra
         * element.
         *
         * Note that rows in the table MUST all be the same height. Information in a cell
         * which expands on to multiple lines will cause some odd behaviour in the scrolling.
         *
         * Scroller is initialised by simply including the letter 'S' in the sDom for the
         * table you want to have this feature enabled on. Note that the 'S' must come
         * AFTER the 't' parameter in `dom`.
         *
         * Key features include:
         *   <ul class="limit_length">
         *     <li>Speed! The aim of Scroller for DataTables is to make rendering large data sets fast</li>
         *     <li>Full compatibility with deferred rendering in DataTables 1.9 for maximum speed</li>
         *     <li>Display millions of rows</li>
         *     <li>Integration with state saving in DataTables (scrolling position is saved)</li>
         *     <li>Easy to use</li>
         *   </ul>
         *
         *  @class
         *  @constructor
         *  @global
         *  @param {object} oDT DataTables settings object
         *  @param {object} [oOpts={}] Configuration object for FixedColumns. Options 
         *    are defined by {@link Scroller.defaults}
         *
         *  @requires jQuery 1.7+
         *  @requires DataTables 1.9.0+
         *
         *  @example
         *    $(document).ready(function() {
         *        $('#example').dataTable( {
         *            "sScrollY": "200px",
         *            "sAjaxSource": "media/dataset/large.txt",
         *            "sDom": "frtiS",
         *            "bDeferRender": true
         *        } );
         *    } );
         */
        var Scroller = function (oDTSettings, oOpts) {
            /* Sanity check - you just know it will happen */
            if (!this instanceof Scroller)
            {
                alert("Scroller warning: Scroller must be initialised with the 'new' keyword.");
                return;
            }

            if (typeof oOpts == 'undefined')
            {
                oOpts = {};
            }

            /**
             * Settings object which contains customisable information for the Scroller instance
             * @namespace
             * @private
             * @extends Scroller.defaults
             */
            this.s = {
                /**
                 * DataTables settings object
                 *  @type     object
                 *  @default  Passed in as first parameter to constructor
                 */
                "dt": oDTSettings,

                /**
                 * Pixel location of the top of the drawn table in the viewport
                 *  @type     int
                 *  @default  0
                 */
                "tableTop": 0,

                /**
                 * Pixel location of the bottom of the drawn table in the viewport
                 *  @type     int
                 *  @default  0
                 */
                "tableBottom": 0,

                /**
                 * Pixel location of the boundary for when the next data set should be loaded and drawn
                 * when scrolling up the way.
                 *  @type     int
                 *  @default  0
                 *  @private
                 */
                "redrawTop": 0,

                /**
                 * Pixel location of the boundary for when the next data set should be loaded and drawn
                 * when scrolling down the way. Note that this is actually calculated as the offset from
                 * the top.
                 *  @type     int
                 *  @default  0
                 *  @private
                 */
                "redrawBottom": 0,

                /**
                 * Auto row height or not indicator
                 *  @type     bool
                 *  @default  0
                 */
                "autoHeight": true,

                /**
                 * Number of rows calculated as visible in the visible viewport
                 *  @type     int
                 *  @default  0
                 */
                "viewportRows": 0,

                /**
                 * setTimeout reference for state saving, used when state saving is enabled in the DataTable
                 * and when the user scrolls the viewport in order to stop the cookie set taking too much
                 * CPU!
                 *  @type     int
                 *  @default  0
                 */
                "stateTO": null,

                /**
                 * setTimeout reference for the redraw, used when server-side processing is enabled in the
                 * DataTables in order to prevent DoSing the server
                 *  @type     int
                 *  @default  null
                 */
                "drawTO": null,

                heights: {
                    jump: null,
                    page: null,
                    virtual: null,
                    scroll: null,

                    /**
                     * Height of rows in the table
                     *  @type     int
                     *  @default  0
                     */
                    row: null,

                    /**
                     * Pixel height of the viewport
                     *  @type     int
                     *  @default  0
                     */
                    viewport: null
                },

                topRowFloat: 0,
                scrollDrawDiff: null,
                loaderVisible: false
            };

            // @todo The defaults should extend a `c` property and the internal settings
            // only held in the `s` property. At the moment they are mixed
            this.s = $.extend(this.s, Scroller.oDefaults, oOpts);

            // Workaround for row height being read from height object (see above comment)
            this.s.heights.row = this.s.rowHeight;

            /**
             * DOM elements used by the class instance
             * @private
             * @namespace
             *
             */
            this.dom = {
                "force": document.createElement('div'),
                "scroller": null,
                "table": null,
                "loader": null
            };

            /* Attach the instance to the DataTables instance so it can be accessed */
            this.s.dt.oScroller = this;

            /* Let's do it */
            this._fnConstruct();
        };



        Scroller.prototype = /** @lends Scroller.prototype */{
            /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
             * Public methods
             * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

            /**
             * Calculate the pixel position from the top of the scrolling container for
             * a given row
             *  @param {int} iRow Row number to calculate the position of
             *  @returns {int} Pixels
             *  @example
             *    $(document).ready(function() {
             *      $('#example').dataTable( {
             *        "sScrollY": "200px",
             *        "sAjaxSource": "media/dataset/large.txt",
             *        "sDom": "frtiS",
             *        "bDeferRender": true,
             *        "fnInitComplete": function (o) {
             *          // Find where row 25 is
             *          alert( o.oScroller.fnRowToPixels( 25 ) );
             *        }
             *      } );
             *    } );
             */
            "fnRowToPixels": function (rowIdx, intParse, virtual)
            {
                var pixels;

                if (virtual) {
                    pixels = this._domain('virtualToPhysical', rowIdx * this.s.heights.row);
                } else {
                    var diff = rowIdx - this.s.baseRowTop;
                    pixels = this.s.baseScrollTop + (diff * this.s.heights.row);
                }

                return intParse || intParse === undefined ?
                        parseInt(pixels, 10) :
                        pixels;
            },

            /**
             * Calculate the row number that will be found at the given pixel position
             * (y-scroll).
             *
             * Please note that when the height of the full table exceeds 1 million
             * pixels, Scroller switches into a non-linear mode for the scrollbar to fit
             * all of the records into a finite area, but this function returns a linear
             * value (relative to the last non-linear positioning).
             *  @param {int} iPixels Offset from top to calculate the row number of
             *  @param {int} [intParse=true] If an integer value should be returned
             *  @param {int} [virtual=false] Perform the calculations in the virtual domain
             *  @returns {int} Row index
             *  @example
             *    $(document).ready(function() {
             *      $('#example').dataTable( {
             *        "sScrollY": "200px",
             *        "sAjaxSource": "media/dataset/large.txt",
             *        "sDom": "frtiS",
             *        "bDeferRender": true,
             *        "fnInitComplete": function (o) {
             *          // Find what row number is at 500px
             *          alert( o.oScroller.fnPixelsToRow( 500 ) );
             *        }
             *      } );
             *    } );
             */
            "fnPixelsToRow": function (pixels, intParse, virtual)
            {
                var diff = pixels - this.s.baseScrollTop;
                var row = virtual ?
                        this._domain('physicalToVirtual', pixels) / this.s.heights.row :
                        (diff / this.s.heights.row) + this.s.baseRowTop;

                return intParse || intParse === undefined ?
                        parseInt(row, 10) :
                        row;
            },

            /**
             * Calculate the row number that will be found at the given pixel position (y-scroll)
             *  @param {int} iRow Row index to scroll to
             *  @param {bool} [bAnimate=true] Animate the transition or not
             *  @returns {void}
             *  @example
             *    $(document).ready(function() {
             *      $('#example').dataTable( {
             *        "sScrollY": "200px",
             *        "sAjaxSource": "media/dataset/large.txt",
             *        "sDom": "frtiS",
             *        "bDeferRender": true,
             *        "fnInitComplete": function (o) {
             *          // Immediately scroll to row 1000
             *          o.oScroller.fnScrollToRow( 1000 );
             *        }
             *      } );
             *     
             *      // Sometime later on use the following to scroll to row 500...
             *          var oSettings = $('#example').dataTable().fnSettings();
             *      oSettings.oScroller.fnScrollToRow( 500 );
             *    } );
             */
            "fnScrollToRow": function (iRow, bAnimate)
            {
                var that = this;
                var ani = false;
                var px = this.fnRowToPixels(iRow);

                // We need to know if the table will redraw or not before doing the
                // scroll. If it will not redraw, then we need to use the currently
                // displayed table, and scroll with the physical pixels. Otherwise, we
                // need to calculate the table's new position from the virtual
                // transform.
                var preRows = ((this.s.displayBuffer - 1) / 2) * this.s.viewportRows;
                var drawRow = iRow - preRows;
                if (drawRow < 0) {
                    drawRow = 0;
                }

                if ((px > this.s.redrawBottom || px < this.s.redrawTop) && this.s.dt._iDisplayStart !== drawRow) {
                    ani = true;
                    px = this.fnRowToPixels(iRow, false, true);
                }

                if (typeof bAnimate == 'undefined' || bAnimate)
                {
                    this.s.ani = ani;
                    $(this.dom.scroller).animate({
                        "scrollTop": px
                    }, function () {
                        // This needs to happen after the animation has completed and
                        // the final scroll event fired
                        setTimeout(function () {
                            that.s.ani = false;
                        }, 25);
                    });
                } else
                {
                    $(this.dom.scroller).scrollTop(px);
                }
            },

            /**
             * Calculate and store information about how many rows are to be displayed
             * in the scrolling viewport, based on current dimensions in the browser's
             * rendering. This can be particularly useful if the table is initially
             * drawn in a hidden element - for example in a tab.
             *  @param {bool} [bRedraw=true] Redraw the table automatically after the recalculation, with
             *    the new dimensions forming the basis for the draw.
             *  @returns {void}
             *  @example
             *    $(document).ready(function() {
             *      // Make the example container hidden to throw off the browser's sizing
             *      document.getElementById('container').style.display = "none";
             *      var oTable = $('#example').dataTable( {
             *        "sScrollY": "200px",
             *        "sAjaxSource": "media/dataset/large.txt",
             *        "sDom": "frtiS",
             *        "bDeferRender": true,
             *        "fnInitComplete": function (o) {
             *          // Immediately scroll to row 1000
             *          o.oScroller.fnScrollToRow( 1000 );
             *        }
             *      } );
             *     
             *      setTimeout( function () {
             *        // Make the example container visible and recalculate the scroller sizes
             *        document.getElementById('container').style.display = "block";
             *        oTable.fnSettings().oScroller.fnMeasure();
             *      }, 3000 );
             */
            "fnMeasure": function (bRedraw)
            {
                if (this.s.autoHeight)
                {
                    this._fnCalcRowHeight();
                }

                var heights = this.s.heights;

                heights.viewport = $(this.dom.scroller).height();
                this.s.viewportRows = parseInt(heights.viewport / heights.row, 10) + 1;
                this.s.dt._iDisplayLength = this.s.viewportRows * this.s.displayBuffer;

                if (bRedraw === undefined || bRedraw)
                {
                    this.s.dt.oInstance.fnDraw();
                }
            },

            /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
             * Private methods (they are of course public in JS, but recommended as private)
             * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

            /**
             * Initialisation for Scroller
             *  @returns {void}
             *  @private
             */
            "_fnConstruct": function ()
            {
                var that = this;

                /* Sanity check */
                if (!this.s.dt.oFeatures.bPaginate) {
                    this.s.dt.oApi._fnLog(this.s.dt, 0, 'Pagination must be enabled for Scroller');
                    return;
                }

                /* Insert a div element that we can use to force the DT scrolling container to
                 * the height that would be required if the whole table was being displayed
                 */
                this.dom.force.style.position = "absolute";
                this.dom.force.style.top = "0px";
                this.dom.force.style.left = "0px";
                this.dom.force.style.width = "1px";

                this.dom.scroller = $('div.' + this.s.dt.oClasses.sScrollBody, this.s.dt.nTableWrapper)[0];
                this.dom.scroller.appendChild(this.dom.force);
                this.dom.scroller.style.position = "relative";

                this.dom.table = $('>table', this.dom.scroller)[0];
                this.dom.table.style.position = "absolute";
                this.dom.table.style.top = "0px";
                this.dom.table.style.left = "0px";

                // Add class to 'announce' that we are a Scroller table
                $(this.s.dt.nTableWrapper).addClass('DTS');

                // Add a 'loading' indicator
                if (this.s.loadingIndicator)
                {
                    this.dom.loader = $('<div class="DTS_Loading">' + this.s.dt.oLanguage.sLoadingRecords + '</div>')
                            .css('display', 'none');

                    $(this.dom.scroller.parentNode)
                            .css('position', 'relative')
                            .append(this.dom.loader);
                }

                /* Initial size calculations */
                if (this.s.heights.row && this.s.heights.row != 'auto')
                {
                    this.s.autoHeight = false;
                }
                this.fnMeasure(false);

                /* Scrolling callback to see if a page change is needed - use a throttled
                 * function for the save save callback so we aren't hitting it on every
                 * scroll
                 */
                this.s.ingnoreScroll = true;
                this.s.stateSaveThrottle = this.s.dt.oApi._fnThrottle(function () {
                    that.s.dt.oApi._fnSaveState(that.s.dt);
                }, 500);
                $(this.dom.scroller).on('scroll.DTS', function (e) {
                    that._fnScroll.call(that);
                });

                /* In iOS we catch the touchstart event in case the user tries to scroll
                 * while the display is already scrolling
                 */
                $(this.dom.scroller).on('touchstart.DTS', function () {
                    that._fnScroll.call(that);
                });

                /* Update the scroller when the DataTable is redrawn */
                this.s.dt.aoDrawCallback.push({
                    "fn": function () {
                        if (that.s.dt.bInitialised) {
                            that._fnDrawCallback.call(that);
                        }
                    },
                    "sName": "Scroller"
                });

                /* On resize, update the information element, since the number of rows shown might change */
                $(window).on('resize.DTS', function () {
                    that.fnMeasure(false);
                    that._fnInfo();
                });

                /* Add a state saving parameter to the DT state saving so we can restore the exact
                 * position of the scrolling
                 */
                var initialStateSave = true;
                this.s.dt.oApi._fnCallbackReg(this.s.dt, 'aoStateSaveParams', function (oS, oData) {
                    /* Set iScroller to saved scroll position on initialization.
                     */
                    if (initialStateSave && that.s.dt.oLoadedState) {
                        oData.iScroller = that.s.dt.oLoadedState.iScroller;
                        oData.iScrollerTopRow = that.s.dt.oLoadedState.iScrollerTopRow;
                        initialStateSave = false;
                    } else {
                        oData.iScroller = that.dom.scroller.scrollTop;
                        oData.iScrollerTopRow = that.s.topRowFloat;
                    }
                }, "Scroller_State");

                if (this.s.dt.oLoadedState) {
                    this.s.topRowFloat = this.s.dt.oLoadedState.iScrollerTopRow || 0;
                }

                /* Destructor */
                this.s.dt.aoDestroyCallback.push({
                    "sName": "Scroller",
                    "fn": function () {
                        $(window).off('resize.DTS');
                        $(that.dom.scroller).off('touchstart.DTS scroll.DTS');
                        $(that.s.dt.nTableWrapper).removeClass('DTS');
                        $('div.DTS_Loading', that.dom.scroller.parentNode).remove();

                        that.dom.table.style.position = "";
                        that.dom.table.style.top = "";
                        that.dom.table.style.left = "";
                    }
                });
            },

            /**
             * Scrolling function - fired whenever the scrolling position is changed.
             * This method needs to use the stored values to see if the table should be
             * redrawn as we are moving towards the end of the information that is
             * currently drawn or not. If needed, then it will redraw the table based on
             * the new position.
             *  @returns {void}
             *  @private
             */
            "_fnScroll": function ()
            {
                var
                        that = this,
                        heights = this.s.heights,
                        iScrollTop = this.dom.scroller.scrollTop,
                        iTopRow;

                if (this.s.skip) {
                    return;
                }

                if (this.s.ingnoreScroll) {
                    return;
                }

                /* If the table has been sorted or filtered, then we use the redraw that
                 * DataTables as done, rather than performing our own
                 */
                if (this.s.dt.bFiltered || this.s.dt.bSorted) {
                    this.s.lastScrollTop = 0;
                    return;
                }

                /* Update the table's information display for what is now in the viewport */
                this._fnInfo();

                /* We don't want to state save on every scroll event - that's heavy
                 * handed, so use a timeout to update the state saving only when the
                 * scrolling has finished
                 */
                clearTimeout(this.s.stateTO);
                this.s.stateTO = setTimeout(function () {
                    that.s.dt.oApi._fnSaveState(that.s.dt);
                }, 250);

                /* Check if the scroll point is outside the trigger boundary which would required
                 * a DataTables redraw
                 */
                if (iScrollTop < this.s.redrawTop || iScrollTop > this.s.redrawBottom) {
                    var preRows = Math.ceil(((this.s.displayBuffer - 1) / 2) * this.s.viewportRows);

                    if (Math.abs(iScrollTop - this.s.lastScrollTop) > heights.viewport || this.s.ani) {
                        iTopRow = parseInt(this._domain('physicalToVirtual', iScrollTop) / heights.row, 10) - preRows;
                        this.s.topRowFloat = (this._domain('physicalToVirtual', iScrollTop) / heights.row);
                    } else {
                        iTopRow = this.fnPixelsToRow(iScrollTop) - preRows;
                        this.s.topRowFloat = this.fnPixelsToRow(iScrollTop, false);
                    }

                    if (iTopRow <= 0) {
                        /* At the start of the table */
                        iTopRow = 0;
                    } else if (iTopRow + this.s.dt._iDisplayLength > this.s.dt.fnRecordsDisplay()) {
                        /* At the end of the table */
                        iTopRow = this.s.dt.fnRecordsDisplay() - this.s.dt._iDisplayLength;
                        if (iTopRow < 0) {
                            iTopRow = 0;
                        }
                    } else if (iTopRow % 2 !== 0) {
                        // For the row-striping classes (odd/even) we want only to start
                        // on evens otherwise the stripes will change between draws and
                        // look rubbish
                        iTopRow++;
                    }

                    if (iTopRow != this.s.dt._iDisplayStart) {
                        /* Cache the new table position for quick lookups */
                        this.s.tableTop = $(this.s.dt.nTable).offset().top;
                        this.s.tableBottom = $(this.s.dt.nTable).height() + this.s.tableTop;

                        var draw = function () {
                            if (that.s.scrollDrawReq === null) {
                                that.s.scrollDrawReq = iScrollTop;
                            }

                            that.s.dt._iDisplayStart = iTopRow;
                            if (that.s.dt.oApi._fnCalculateEnd) { // Removed in 1.10
                                that.s.dt.oApi._fnCalculateEnd(that.s.dt);
                            }
                            that.s.dt.oApi._fnDraw(that.s.dt);
                        };

                        /* Do the DataTables redraw based on the calculated start point - note that when
                         * using server-side processing we introduce a small delay to not DoS the server...
                         */
                        if (this.s.dt.oFeatures.bServerSide) {
                            clearTimeout(this.s.drawTO);
                            this.s.drawTO = setTimeout(draw, this.s.serverWait);
                        } else {
                            draw();
                        }

                        if (this.dom.loader && !this.s.loaderVisible) {
                            this.dom.loader.css('display', 'block');
                            this.s.loaderVisible = true;
                        }
                    }
                }

                this.s.lastScrollTop = iScrollTop;
                this.s.stateSaveThrottle();
            },

            /**
             * Convert from one domain to another. The physical domain is the actual
             * pixel count on the screen, while the virtual is if we had browsers which
             * had scrolling containers of infinite height (i.e. the absolute value)
             *
             *  @param {string} dir Domain transform direction, `virtualToPhysical` or
             *    `physicalToVirtual` 
             *  @returns {number} Calculated transform
             *  @private
             */
            _domain: function (dir, val)
            {
                var heights = this.s.heights;
                var coeff;

                // If the virtual and physical height match, then we use a linear
                // transform between the two, allowing the scrollbar to be linear
                if (heights.virtual === heights.scroll) {
                    coeff = (heights.virtual - heights.viewport) / (heights.scroll - heights.viewport);

                    if (dir === 'virtualToPhysical') {
                        return val / coeff;
                    } else if (dir === 'physicalToVirtual') {
                        return val * coeff;
                    }
                }

                // Otherwise, we want a non-linear scrollbar to take account of the
                // redrawing regions at the start and end of the table, otherwise these
                // can stutter badly - on large tables 30px (for example) scroll might
                // be hundreds of rows, so the table would be redrawing every few px at
                // the start and end. Use a simple quadratic to stop this. It does mean
                // the scrollbar is non-linear, but with such massive data sets, the
                // scrollbar is going to be a best guess anyway
                var xMax = (heights.scroll - heights.viewport) / 2;
                var yMax = (heights.virtual - heights.viewport) / 2;

                coeff = yMax / (xMax * xMax);

                if (dir === 'virtualToPhysical') {
                    if (val < yMax) {
                        return Math.pow(val / coeff, 0.5);
                    } else {
                        val = (yMax * 2) - val;
                        return val < 0 ?
                                heights.scroll :
                                (xMax * 2) - Math.pow(val / coeff, 0.5);
                    }
                } else if (dir === 'physicalToVirtual') {
                    if (val < xMax) {
                        return val * val * coeff;
                    } else {
                        val = (xMax * 2) - val;
                        return val < 0 ?
                                heights.virtual :
                                (yMax * 2) - (val * val * coeff);
                    }
                }
            },

            /**
             * Draw callback function which is fired when the DataTable is redrawn. The main function of
             * this method is to position the drawn table correctly the scrolling container for the rows
             * that is displays as a result of the scrolling position.
             *  @returns {void}
             *  @private
             */
            "_fnDrawCallback": function ()
            {
                var
                        that = this,
                        heights = this.s.heights,
                        iScrollTop = this.dom.scroller.scrollTop,
                        iActualScrollTop = iScrollTop,
                        iScrollBottom = iScrollTop + heights.viewport,
                        iTableHeight = $(this.s.dt.nTable).height(),
                        displayStart = this.s.dt._iDisplayStart,
                        displayLen = this.s.dt._iDisplayLength,
                        displayEnd = this.s.dt.fnRecordsDisplay();

                // Disable the scroll event listener while we are updating the DOM
                this.s.skip = true;

                // Resize the scroll forcing element
                this._fnScrollForce();

                // Reposition the scrolling for the updated virtual position if needed
                if (displayStart === 0) {
                    // Linear calculation at the top of the table
                    iScrollTop = this.s.topRowFloat * heights.row;
                } else if (displayStart + displayLen >= displayEnd) {
                    // Linear calculation that the bottom as well
                    iScrollTop = heights.scroll - ((displayEnd - this.s.topRowFloat) * heights.row);
                } else {
                    // Domain scaled in the middle
                    iScrollTop = this._domain('virtualToPhysical', this.s.topRowFloat * heights.row);
                }

                this.dom.scroller.scrollTop = iScrollTop;

                // Store positional information so positional calculations can be based
                // upon the current table draw position
                this.s.baseScrollTop = iScrollTop;
                this.s.baseRowTop = this.s.topRowFloat;

                // Position the table in the virtual scroller
                var tableTop = iScrollTop - ((this.s.topRowFloat - displayStart) * heights.row);
                if (displayStart === 0) {
                    tableTop = 0;
                } else if (displayStart + displayLen >= displayEnd) {
                    tableTop = heights.scroll - iTableHeight;
                }

                this.dom.table.style.top = tableTop + 'px';

                /* Cache some information for the scroller */
                this.s.tableTop = tableTop;
                this.s.tableBottom = iTableHeight + this.s.tableTop;

                // Calculate the boundaries for where a redraw will be triggered by the
                // scroll event listener
                var boundaryPx = (iScrollTop - this.s.tableTop) * this.s.boundaryScale;
                this.s.redrawTop = iScrollTop - boundaryPx;
                this.s.redrawBottom = iScrollTop + boundaryPx;

                this.s.skip = false;

                // Restore the scrolling position that was saved by DataTable's state
                // saving Note that this is done on the second draw when data is Ajax
                // sourced, and the first draw when DOM soured
                if (this.s.dt.oFeatures.bStateSave && this.s.dt.oLoadedState !== null &&
                        typeof this.s.dt.oLoadedState.iScroller != 'undefined')
                {
                    // A quirk of DataTables is that the draw callback will occur on an
                    // empty set if Ajax sourced, but not if server-side processing.
                    var ajaxSourced = (this.s.dt.sAjaxSource || that.s.dt.ajax) && !this.s.dt.oFeatures.bServerSide ?
                            true :
                            false;

                    if ((ajaxSourced && this.s.dt.iDraw == 2) ||
                            (!ajaxSourced && this.s.dt.iDraw == 1))
                    {
                        setTimeout(function () {
                            $(that.dom.scroller).scrollTop(that.s.dt.oLoadedState.iScroller);
                            that.s.redrawTop = that.s.dt.oLoadedState.iScroller - (heights.viewport / 2);

                            // In order to prevent layout thrashing we need another
                            // small delay
                            setTimeout(function () {
                                that.s.ingnoreScroll = false;
                            }, 0);
                        }, 0);
                    }
                } else {
                    that.s.ingnoreScroll = false;
                }

                // Because of the order of the DT callbacks, the info update will
                // take precedence over the one we want here. So a 'thread' break is
                // needed
                setTimeout(function () {
                    that._fnInfo.call(that);
                }, 0);

                // Hide the loading indicator
                if (this.dom.loader && this.s.loaderVisible) {
                    this.dom.loader.css('display', 'none');
                    this.s.loaderVisible = false;
                }
            },

            /**
             * Force the scrolling container to have height beyond that of just the
             * table that has been drawn so the user can scroll the whole data set.
             *
             * Note that if the calculated required scrolling height exceeds a maximum
             * value (1 million pixels - hard-coded) the forcing element will be set
             * only to that maximum value and virtual / physical domain transforms will
             * be used to allow Scroller to display tables of any number of records.
             *  @returns {void}
             *  @private
             */
            _fnScrollForce: function ()
            {
                var heights = this.s.heights;
                var max = 1000000;

                heights.virtual = heights.row * this.s.dt.fnRecordsDisplay();
                heights.scroll = heights.virtual;

                if (heights.scroll > max) {
                    heights.scroll = max;
                }

                this.dom.force.style.height = heights.scroll + "px";
            },

            /**
             * Automatic calculation of table row height. This is just a little tricky here as using
             * initialisation DataTables has tale the table out of the document, so we need to create
             * a new table and insert it into the document, calculate the row height and then whip the
             * table out.
             *  @returns {void}
             *  @private
             */
            "_fnCalcRowHeight": function ()
            {
                var dt = this.s.dt;
                var origTable = dt.nTable;
                var nTable = origTable.cloneNode(false);
                var tbody = $('<tbody/>').appendTo(nTable);
                var container = $(
                        '<div class="' + dt.oClasses.sWrapper + ' DTS">' +
                        '<div class="' + dt.oClasses.sScrollWrapper + '">' +
                        '<div class="' + dt.oClasses.sScrollBody + '"></div>' +
                        '</div>' +
                        '</div>'
                        );

                // Want 3 rows in the sizing table so :first-child and :last-child
                // CSS styles don't come into play - take the size of the middle row
                $('tbody tr:lt(4)', origTable).clone().appendTo(tbody);
                while ($('tr', tbody).length < 3) {
                    tbody.append('<tr><td>&nbsp;</td></tr>');
                }

                $('div.' + dt.oClasses.sScrollBody, container).append(nTable);

                var appendTo;
                if (dt._bInitComplete) {
                    appendTo = origTable.parentNode;
                } else {
                    if (!this.s.dt.nHolding) {
                        this.s.dt.nHolding = $('<div></div>').insertBefore(this.s.dt.nTable);
                    }
                    appendTo = this.s.dt.nHolding;
                }

                container.appendTo(appendTo);
                this.s.heights.row = $('tr', tbody).eq(1).outerHeight();
                container.remove();
            },

            /**
             * Update any information elements that are controlled by the DataTable based on the scrolling
             * viewport and what rows are visible in it. This function basically acts in the same way as
             * _fnUpdateInfo in DataTables, and effectively replaces that function.
             *  @returns {void}
             *  @private
             */
            "_fnInfo": function ()
            {
                if (!this.s.dt.oFeatures.bInfo)
                {
                    return;
                }

                var
                        dt = this.s.dt,
                        language = dt.oLanguage,
                        iScrollTop = this.dom.scroller.scrollTop,
                        iStart = Math.floor(this.fnPixelsToRow(iScrollTop, false, this.s.ani) + 1),
                        iMax = dt.fnRecordsTotal(),
                        iTotal = dt.fnRecordsDisplay(),
                        iPossibleEnd = Math.ceil(this.fnPixelsToRow(iScrollTop + this.s.heights.viewport, false, this.s.ani)),
                        iEnd = iTotal < iPossibleEnd ? iTotal : iPossibleEnd,
                        sStart = dt.fnFormatNumber(iStart),
                        sEnd = dt.fnFormatNumber(iEnd),
                        sMax = dt.fnFormatNumber(iMax),
                        sTotal = dt.fnFormatNumber(iTotal),
                        sOut;

                if (dt.fnRecordsDisplay() === 0 &&
                        dt.fnRecordsDisplay() == dt.fnRecordsTotal())
                {
                    /* Empty record set */
                    sOut = language.sInfoEmpty + language.sInfoPostFix;
                } else if (dt.fnRecordsDisplay() === 0)
                {
                    /* Empty record set after filtering */
                    sOut = language.sInfoEmpty + ' ' +
                            language.sInfoFiltered.replace('_MAX_', sMax) +
                            language.sInfoPostFix;
                } else if (dt.fnRecordsDisplay() == dt.fnRecordsTotal())
                {
                    /* Normal record set */
                    sOut = language.sInfo.
                            replace('_START_', sStart).
                            replace('_END_', sEnd).
                            replace('_MAX_', sMax).
                            replace('_TOTAL_', sTotal) +
                            language.sInfoPostFix;
                } else
                {
                    /* Record set after filtering */
                    sOut = language.sInfo.
                            replace('_START_', sStart).
                            replace('_END_', sEnd).
                            replace('_MAX_', sMax).
                            replace('_TOTAL_', sTotal) + ' ' +
                            language.sInfoFiltered.replace(
                                    '_MAX_',
                                    dt.fnFormatNumber(dt.fnRecordsTotal())
                                    ) +
                            language.sInfoPostFix;
                }

                var callback = language.fnInfoCallback;
                if (callback) {
                    sOut = callback.call(dt.oInstance,
                            dt, iStart, iEnd, iMax, iTotal, sOut
                            );
                }

                var n = dt.aanFeatures.i;
                if (typeof n != 'undefined')
                {
                    for (var i = 0, iLen = n.length; i < iLen; i++)
                    {
                        $(n[i]).html(sOut);
                    }
                }
            }
        };



        /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
         * Statics
         * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */


        /**
         * Scroller default settings for initialisation
         *  @namespace
         *  @name Scroller.defaults
         *  @static
         */
        Scroller.defaults = /** @lends Scroller.defaults */{
            /**
             * Indicate if Scroller show show trace information on the console or not. This can be
             * useful when debugging Scroller or if just curious as to what it is doing, but should
             * be turned off for production.
             *  @type     bool
             *  @default  false
             *  @static
             *  @example
             *    var oTable = $('#example').dataTable( {
             *        "sScrollY": "200px",
             *        "sDom": "frtiS",
             *        "bDeferRender": true,
             *        "oScroller": {
             *          "trace": true
             *        }
             *    } );
             */
            "trace": false,

            /**
             * Scroller will attempt to automatically calculate the height of rows for it's internal
             * calculations. However the height that is used can be overridden using this parameter.
             *  @type     int|string
             *  @default  auto
             *  @static
             *  @example
             *    var oTable = $('#example').dataTable( {
             *        "sScrollY": "200px",
             *        "sDom": "frtiS",
             *        "bDeferRender": true,
             *        "oScroller": {
             *          "rowHeight": 30
             *        }
             *    } );
             */
            "rowHeight": "auto",

            /**
             * When using server-side processing, Scroller will wait a small amount of time to allow
             * the scrolling to finish before requesting more data from the server. This prevents
             * you from DoSing your own server! The wait time can be configured by this parameter.
             *  @type     int
             *  @default  200
             *  @static
             *  @example
             *    var oTable = $('#example').dataTable( {
             *        "sScrollY": "200px",
             *        "sDom": "frtiS",
             *        "bDeferRender": true,
             *        "oScroller": {
             *          "serverWait": 100
             *        }
             *    } );
             */
            "serverWait": 200,

            /**
             * The display buffer is what Scroller uses to calculate how many rows it should pre-fetch
             * for scrolling. Scroller automatically adjusts DataTables' display length to pre-fetch
             * rows that will be shown in "near scrolling" (i.e. just beyond the current display area).
             * The value is based upon the number of rows that can be displayed in the viewport (i.e.
             * a value of 1), and will apply the display range to records before before and after the
             * current viewport - i.e. a factor of 3 will allow Scroller to pre-fetch 1 viewport's worth
             * of rows before the current viewport, the current viewport's rows and 1 viewport's worth
             * of rows after the current viewport. Adjusting this value can be useful for ensuring
             * smooth scrolling based on your data set.
             *  @type     int
             *  @default  7
             *  @static
             *  @example
             *    var oTable = $('#example').dataTable( {
             *        "sScrollY": "200px",
             *        "sDom": "frtiS",
             *        "bDeferRender": true,
             *        "oScroller": {
             *          "displayBuffer": 10
             *        }
             *    } );
             */
            "displayBuffer": 9,

            /**
             * Scroller uses the boundary scaling factor to decide when to redraw the table - which it
             * typically does before you reach the end of the currently loaded data set (in order to
             * allow the data to look continuous to a user scrolling through the data). If given as 0
             * then the table will be redrawn whenever the viewport is scrolled, while 1 would not
             * redraw the table until the currently loaded data has all been shown. You will want
             * something in the middle - the default factor of 0.5 is usually suitable.
             *  @type     float
             *  @default  0.5
             *  @static
             *  @example
             *    var oTable = $('#example').dataTable( {
             *        "sScrollY": "200px",
             *        "sDom": "frtiS",
             *        "bDeferRender": true,
             *        "oScroller": {
             *          "boundaryScale": 0.75
             *        }
             *    } );
             */
            "boundaryScale": 0.5,

            /**
             * Show (or not) the loading element in the background of the table. Note that you should
             * include the dataTables.scroller.css file for this to be displayed correctly.
             *  @type     boolean
             *  @default  false
             *  @static
             *  @example
             *    var oTable = $('#example').dataTable( {
             *        "sScrollY": "200px",
             *        "sDom": "frtiS",
             *        "bDeferRender": true,
             *        "oScroller": {
             *          "loadingIndicator": true
             *        }
             *    } );
             */
            "loadingIndicator": false
        };

        Scroller.oDefaults = Scroller.defaults;



        /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
         * Constants
         * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

        /**
         * Scroller version
         *  @type      String
         *  @default   See code
         *  @name      Scroller.version
         *  @static
         */
        Scroller.version = "1.2.2";



        /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
         * Initialisation
         * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

        /*
         * Register a new feature with DataTables
         */
        if (typeof $.fn.dataTable == "function" &&
                typeof $.fn.dataTableExt.fnVersionCheck == "function" &&
                $.fn.dataTableExt.fnVersionCheck('1.9.0'))
        {
            $.fn.dataTableExt.aoFeatures.push({
                "fnInit": function (oDTSettings) {
                    var init = oDTSettings.oInit;
                    var opts = init.scroller || init.oScroller || {};
                    var oScroller = new Scroller(oDTSettings, opts);
                    return oScroller.dom.wrapper;
                },
                "cFeature": "S",
                "sFeature": "Scroller"
            });
        } else
        {
            alert("Warning: Scroller requires DataTables 1.9.0 or greater - www.datatables.net/download");
        }


// Attach Scroller to DataTables so it can be accessed as an 'extra'
        $.fn.dataTable.Scroller = Scroller;
        $.fn.DataTable.Scroller = Scroller;


// DataTables 1.10 API method aliases
        if ($.fn.dataTable.Api) {
            var Api = $.fn.dataTable.Api;

            Api.register('scroller()', function () {
                return this;
            });

            Api.register('scroller().rowToPixels()', function (rowIdx, intParse, virtual) {
                var ctx = this.context;

                if (ctx.length && ctx[0].oScroller) {
                    return ctx[0].oScroller.fnRowToPixels(rowIdx, intParse, virtual);
                }
                // undefined
            });

            Api.register('scroller().pixelsToRow()', function (pixels, intParse, virtual) {
                var ctx = this.context;

                if (ctx.length && ctx[0].oScroller) {
                    return ctx[0].oScroller.fnPixelsToRow(pixels, intParse, virtual);
                }
                // undefined
            });

            Api.register('scroller().scrollToRow()', function (row, ani) {
                this.iterator('table', function (ctx) {
                    if (ctx.oScroller) {
                        ctx.oScroller.fnScrollToRow(row, ani);
                    }
                });

                return this;
            });

            Api.register('scroller().measure()', function (redraw) {
                this.iterator('table', function (ctx) {
                    if (ctx.oScroller) {
                        ctx.oScroller.fnMeasure(redraw);
                    }
                });

                return this;
            });
        }


        return Scroller;
    }; // /factory


// Define as an AMD module if possible
    if (typeof define === 'function' && define.amd) {
        define(['jquery', 'datatables'], factory);
    } else if (typeof exports === 'object') {
        // Node/CommonJS
        factory(require('jquery'), require('datatables'));
    } else if (jQuery && !jQuery.fn.dataTable.Scroller) {
        // Otherwise simply initialise as normal, stopping multiple evaluation
        factory(jQuery, jQuery.fn.dataTable);
    }


})(window, document);

